home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / XPK / Source / libraries / NUKE / xpkNUKE.c < prev   
Encoding:
C/C++ Source or Header  |  1997-06-06  |  3.9 KB  |  179 lines
  1. /*
  2.  * This library is mainly intended to demonstrate how to program a sub
  3.  * library.
  4.  */
  5.  
  6. #include <xpk/xpksub.h>
  7. #include <exec/memory.h>
  8. #include <pragma/exec_lib.h>
  9.  
  10. #define SDI_TO_ANSI
  11. #include "SDI_ASM_STD_protos.h"
  12.  
  13. #define SCANBUFLEN 32768
  14.  
  15. /*
  16.  * Pack a chunk
  17.  */
  18.  
  19. struct NukeData {
  20.     APTR    inbuf;
  21.     APTR    outbuf;
  22.     APTR    last;
  23.     APTR    next;
  24.     ULONG    cwri;
  25.     ULONG    uwri;
  26.     ULONG    uend;
  27.     ULONG    delpos;
  28.     UWORD    ulen;
  29.     UWORD    clen;
  30.     UWORD    ustop;
  31.     UWORD    ustart;
  32.     UWORD    ucount;
  33.     UWORD    scanrange;
  34.     UWORD    room1;
  35.     UWORD    room2;
  36.     UWORD    room4;
  37.     UWORD    roomN;
  38.     UWORD    data1;
  39.     UWORD    data2;
  40.     ULONG    data4;
  41.     ULONG    dataN;
  42.     ULONG    dest1;
  43.     ULONG    dest2;
  44.     ULONG    dest4;
  45.     ULONG    destN;
  46.     ULONG    dummy;
  47.     ULONG    contbuf;
  48.     ULONG    flags;
  49. };
  50.  
  51. #ifdef __cplusplus
  52. extern "C" {
  53. #endif
  54.  
  55. LONG   __asm AsmPack  (register __a4 struct NukeData *ND);
  56. STRPTR __asm AsmUnpack(register __a1 STRPTR wread, register __a4 STRPTR bread,
  57.                         register __a0 STRPTR dst, register __a2 STRPTR end);
  58. #ifdef __cplusplus
  59. }
  60. #endif
  61.  
  62. #define PACKMEM   (65536+SCANBUFLEN)*sizeof(UWORD)+sizeof(struct NukeData)
  63.  
  64. static struct XpkMode NukeMode = {
  65.   NULL,       // Next mode
  66.   100,        // Handles up to
  67.   XPKMF_A3000SPEED,      // Flags
  68.   PACKMEM,    // Packing memory
  69.   0,          // Unpacking memory
  70.   36,         // Packing speed
  71.   630,        // Unpacking speed
  72.   454,        // Compression ratio
  73.   0,          // Reserved
  74.   "normal",   // Description
  75. };
  76.  
  77. static struct XpkInfo NukeInfo = {
  78.     1,               /* info version */
  79.     1,               /* lib  version */
  80.     0,               /* master vers  */
  81.     1,               /* ModesVersion */
  82.     "NUKE"  ,        /* short name   */
  83.     "Nuke",          /* long name    */
  84.     "A relatively efficient packer that unpacks very quickly", /* Description */
  85.     0x4E554B45,    /* 'NUKE', 4 letter ID  */
  86.     XPKIF_PK_CHUNK | /* flags        */
  87.     XPKIF_UP_CHUNK,
  88.     30000,           /* max in chunk */
  89.     10,              /* min in chunk */
  90.     30000,           /* def in chunk */
  91.     "Nuking",        /* pk message   */
  92.     "Unnuking",      /* up message   */
  93.     "Nuked",         /* pk past msg  */
  94.     "Unnuked",       /* up past msg  */
  95.     50,              /* DefMode      */
  96.     0,               /* Pad          */
  97.     &NukeMode,       /* ModeDesc     */
  98.     0,               /* MinModeDesc  */
  99.     0,               /* MaxModeDesc  */
  100.     {0}              /* reserved     */
  101. };
  102.  
  103.  
  104. /*
  105.  * Returns an info structure about our packer
  106.  */
  107.  
  108. struct XpkInfo * __asm XpksPackerInfo(void)
  109. {
  110.     return &NukeInfo;
  111. }
  112.  
  113. #define LASTSIZE    (65536*sizeof(UWORD))
  114. #define NEXTSIZE    (SCANBUFLEN*sizeof(UWORD))
  115.  
  116. void __asm XpksPackFree(register __a0 struct XpkSubParams *xpar)
  117. {
  118.   struct NukeData *ND=(struct NukeData *)xpar->xsp_Sub[0];
  119.  
  120.   if(ND)
  121.   {
  122.     if(ND->last) FreeMem(ND->last, LASTSIZE);
  123.     if(ND->next) FreeMem(ND->next, NEXTSIZE);
  124.     FreeMem(ND, sizeof(struct NukeData));
  125.     xpar->xsp_Sub[0] = 0;
  126.   }
  127. }
  128.  
  129. struct NukeData *alloctabs(struct XpkSubParams *xpar)
  130. {
  131.   struct NukeData *ND;
  132.  
  133.   if((xpar->xsp_Sub[0] = (LONG) (ND = (struct NukeData *) AllocMem(sizeof(struct NukeData),MEMF_CLEAR))) &&
  134.       (ND->last = AllocMem(LASTSIZE,0)) &&
  135.       (ND->next = AllocMem(NEXTSIZE,0)))
  136.     return ND;
  137.   else
  138.   {
  139.     XpksPackFree(xpar);
  140.     return 0;
  141.   }
  142. }
  143.  
  144. LONG __asm XpksPackChunk(register __a0 struct XpkSubParams *xpar)
  145. {
  146.   struct NukeData *ND = (struct NukeData *)xpar->xsp_Sub[0];
  147.  
  148.   if(!ND)
  149.     if(!(ND=alloctabs(xpar)))
  150.       return XPKERR_NOMEM;
  151.  
  152.   ND->inbuf = xpar->xsp_InBuf;
  153.   ND->outbuf= xpar->xsp_OutBuf;
  154.   ND->ulen  = xpar->xsp_InLen;
  155.   ND->clen  = xpar->xsp_OutBufLen-4;
  156.  
  157.   memset(ND->last,0,LASTSIZE);
  158.   memset(ND->next,0,NEXTSIZE);
  159.  
  160.   if(((LONG)(xpar->xsp_OutLen = AsmPack(ND)))<0 || xpar->xsp_OutLen>xpar->xsp_InLen)
  161.     return XPKERR_EXPANSION;
  162.   return 0;
  163. }
  164.  
  165. LONG __asm XpksUnpackChunk(register __a0 struct XpkSubParams *xpar)
  166. {
  167. //  APTR end;
  168.  
  169. //  end=
  170.   AsmUnpack(xpar->xsp_InBuf, (STRPTR)xpar->xsp_InBuf  + xpar->xsp_InLen,
  171.             xpar->xsp_OutBuf, (STRPTR)xpar->xsp_OutBuf + xpar->xsp_OutLen);
  172.  
  173. //  if( xpar->xsp_OutBuf+xpar->xsp_OutLen != end )
  174. //    return XPKERR_CORRUPTPKD;
  175.  
  176.   return 0;
  177. }
  178.  
  179.